package hn.cch.grammar.java;

import java.util.Arrays;
import java.util.List;

public class ArrayUtil {


    /**
     * 在校验长度为偶数的前提下将String按两位组合转化为IntArray
     *
     * @param string 长度为偶数的字符串
     * @return 整型数组
     */

    public static int[] toTwobitIntArray(String string) {
        int[] arrays = new int[string.length() / 2];
        for (int i = 0; i < arrays.length; i++) {
            arrays[i] = Integer.parseInt(string.substring(i * 2, (i + 1) * 2));
        }
        return arrays;
    }

    /**
     * 将整型数组按从小到大排序（保持原数组数值和位置都不变）
     *
     * @param nosort
     * @return 返回排序后的整型数组
     */

    public static int[] toSortedIntArray(int[] nosort) {

        // int[] sorted = new int[nosort.length];

        // for (int i = 0; i < nosort.length; i++) {
        //     sorted[i] = nosort[i];
        // }

        // System.arraycopy(nosort, 0, sorted, 0, nosort.length);

        int[] sorted = Arrays.copyOf(nosort, nosort.length);

        // int[] sorted = nosort.clone();

        // 交换临时变量
        int temp;
        for (int i = 0; i < sorted.length; i++) {
            for (int j = i + 1; j < sorted.length; j++) {
                // 从小到大排序
                if (sorted[i] > sorted[j]) {
                    temp = sorted[i];
                    sorted[i] = sorted[j];
                    sorted[j] = temp;
                }
            }
        }
        return sorted;
    }

    /**
     * 判断整型数组是否按升序排列的
     *
     * @param array
     * @return
     */

    public static boolean isSortedIntArray(int[] array) {
        // 数值长度小于二的一定是升序的
        if (array.length < 2) {
            return true;
        }

        for (int i = 0; i < array.length - 1; i++) {
            if (array[i] > array[i + 1]) {
                return false;
            }
        }
        return true;

    }

    /**
     * 校验一个从小到大排序的整型数组是否存在重复元素
     *
     * @param sorted 从小到大排序的整型数组
     * @return 布尔类型
     */

    public static boolean noRepeatOneArray(int[] sorted) {
        if (sorted == null || sorted.length <= 1) {
            return true;
        }
        for (int i = 0; i < sorted.length - 1; i++) {
            if (sorted[i] == sorted[i + 1]) {
                return false;
            }
        }
        return true;
    }

    /**
     * 校验两个个从小到大排序的整型数组是否存在重复元素
     *
     * @param arrayi
     * @param arrayj
     * @return 不重复返回true 有重复返回false
     */
    public static boolean noRepeatTwoArray(int[] arrayi, int[] arrayj) {
        int i = 0;
        int j = 0;
        for (; i < arrayi.length && j < arrayj.length; ) {
            if (arrayi[i] < arrayj[j]) {
                i++;
            } else if (arrayi[i] > arrayj[j]) {
                j++;
            } else {//相等重复
                return false;
            }
        }
        return true;

    }




    /**
     * 将List<Double>转换成double[]
     *
     * @param list
     * @return
     */
    public static double[] toDoubleListArray(List<Double> list) {
        double[] array = new double[list.size()];
        for (int i = 0; i < list.size(); i++) {
            array[i] = list.get(i);
        }
        return array;
    }


    public static void main(String[] args) {
        // String string = "100209032352345712340734912374192678123478901829347109234763";
        // String string = "09080706050403020100";
        String string = "01030507091113151719";
        int[] intArray = ArrayUtil.toTwobitIntArray(string);


        String strs = "00020406081012141618";
        int[] ints = ArrayUtil.toTwobitIntArray(strs);
        int[] int0 = ArrayUtil.toSortedIntArray(intArray);
        int[] int1 = ArrayUtil.toSortedIntArray(ints);
        boolean noRepeatTwoArray = ArrayUtil.noRepeatTwoArray(int0, int1);
        System.out.println(noRepeatTwoArray);
    }
}
